// Package go_channel_groutine main
// @Title go_channel_groutine
// @Description
// @Author  == 琳琳也叫王木木 ==  2022-01-08 21:33
// @Create  2022-01-08 21:33
package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

/**
 使用groutine和channel实现一个计算int64随机数各位数和的程序
1. 开启一个goroutine循环生成int64类型的随机数，发送到jobChannel
2. 开启24个goroutine从jobChannel中取出随机数计算各位数的和，将结果发送到resultChannel中
3. 主groutine 从resultchan中取出结果并打印到终端输出
*/

// 定义一个job结构体，只有一个成员
type Job struct {
	x int64
}

// 定义一个result结构体，有job和int两个类型
type Result struct {
	Job
	result int64
}

var jobChan = make(chan *Job, 100)
var resChan = make(chan *Result, 100)
var wg sync.WaitGroup

func producer(job chan<- *Job) {
	defer wg.Done()
	for {
		rand.Seed(time.Now().Unix())
		temp := rand.Int63()
		j := Job{x: temp}
		job <- &j
		time.Sleep(time.Second * time.Duration(2))
	}
}

func consumer(job <-chan *Job, res chan<- *Result) {
	for {
		t := <-job
		var sum int64
		n := t.x
		for n > 0 {
			sum += n % 10
			n /= 10
		}
		result := Result{
			*t,
			sum,
		}
		res <- &result
	}
}

func main() {
	wg.Add(1)
	go producer(jobChan)
	wg.Add(24)
	for i := 0; i < 24; i++ {
		go consumer(jobChan, resChan)
	}
	// 从resChan中获取结果 打印
	for r := range resChan {
		fmt.Println(r.Job.x, r.result)
	}
	wg.Wait()
}

///**
//	随机生成int64位整数，并发送给channel
// */
//func generateRandInt(jobChan chan<- int){
//	rand.Seed(time.Now().Unix())
//	s := rand.Int()
//	fmt.Println("生成int整数为；",s)
//	jobChan <- s
//}
//
///**
//	从jobchannel中获取对应的int整数，计算和，输入到result中
// */
//func jobChannel(id int, jobChan <-chan int, result chan<- int) {
//	fmt.Println("当前线程id为:",id)
//	res := <-jobChan
//	var sum int
//	for res > 0{
//		sum += res %10
//		res /= 10
//	}
//	result <- sum
//}
//
//func main() {
//	var resChan = make(chan int,10)
//	var jobChan = make(chan int,10)
//	go generateRandInt(jobChan)
//	go jobChannel(1,jobChan,resChan)
//	fmt.Println(<-resChan)
//	time.Sleep(time.Second)
//}
